home *** CD-ROM | disk | FTP | other *** search
/ WOW! 2 / WOW - Vol 2.iso / pd_share / dfue / catrondo / catrondo.c next >
C/C++ Source or Header  |  1994-10-16  |  33KB  |  1,102 lines
  1. /************************************************************************/
  2. /*                                                                        */
  3. /*        CATRONDO.C                                                        */
  4. /*                                                                        */
  5. /*        Rundschreibengenerator für CAT                                    */
  6. /*                                                                        */
  7. /*        Matthias Stürmer (C)1993                                        */
  8. /*                                                                        */
  9. /*        **********************************************************        */
  10. /*                                                                        */
  11. /*        1.0        13.8.93        ms@ka2    erste Release                        */
  12. /*        1.1        26.8.93        ms@ka2    Erweiterung um Verteilerliste        */
  13. /*        1.2        30.8.93        ms@ka2    Returncode für CAT                    */
  14. /*                 8.9.93        ms@ka2    Bugfix für TOS 2.06 und größer        */
  15. /*                                                                        */
  16. /************************************************************************/
  17. /*        Tabsize:    4                                                    */
  18.  
  19. /* -------------------------------------------------------------------- */
  20. /*        Headerdateien einbinden.                                        */
  21. /* -------------------------------------------------------------------- */
  22.  
  23. #include <string.h>
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <aes.h>
  27. #include <tos.h>
  28.  
  29. #include "catrondo.h"
  30.  
  31. /* -------------------------------------------------------------------- */
  32. /*        int main ( int argc, const char *argv[] );                        */
  33. /*                                                                        */
  34. /*        Kernstück des Programms.                                        */
  35. /*                                                                        */
  36. /*        ->    argc            Anzahl der Argumente.                        */
  37. /*            argv            Argumente.                                    */
  38. /*            1. Parameter:    Quelltext.                                    */
  39. /*            2. Parameter:    Zieltext.                                    */
  40. /*                                                                        */
  41. /*        <-    fehler            Exit-Wert.                                    */
  42. /* -------------------------------------------------------------------- */
  43.  
  44. int main ( void )
  45. {
  46.  RUNDINFO    rund;
  47.  MEMBLK        rundinfopuffer, msginfopuffer;
  48.  MSGINFO    *msg;
  49.  int        fehler = 0;
  50.  BOOLEAN    heureka = FALSE;
  51.  
  52.  fehler = datei_laden( rundinfodatei, &rundinfopuffer );
  53.  fehler_auswerten( rundinfodatei, fehler );
  54.  if ( fehler == 0 )
  55.     {
  56.     fehler = rundinfo_auswerten( &rundinfopuffer, &rund );
  57.     fehler_auswerten( rundinfodatei, fehler );
  58.     Mfree( rundinfopuffer.start );
  59.     if ( (fehler == 0) && (Fsfirst( rund.msginfodatei, 0 ) == 0) )
  60.     /*    kein Fehler  und  MSGINFO.DAT gefunden */
  61.         {
  62.         do    {
  63.             fehler = datei_laden( rund.msginfodatei, &msginfopuffer );
  64.             fehler_auswerten( rund.msginfodatei, fehler );
  65.             if ( fehler == 0 )
  66.                 {
  67.                 rund.hoechste_nummer = hoechste_nummer( &msginfopuffer );
  68.                 fehler = rundschreiben_suchen( &msginfopuffer, &rund, &msg );
  69.                 if ( fehler == 0 )
  70.                     {
  71.                     heureka = TRUE;
  72.                     fehler = rundschreiben( &rund, msg );
  73.                     }
  74.                 Mfree( msginfopuffer.start );
  75.                 }
  76.             } while ( fehler == 0 );
  77.         }
  78.     }
  79.  if ( !heureka )
  80.     fehler_auswerten( rund.msginfodatei, 1 ); /* Nichts zu tun */
  81.  else if ( fehler == 1 )
  82.     fehler = 0;
  83.  
  84.  if ( fehler == 0 )
  85.     fehler = 0x4713;        /* CAT.INF einlesen    */
  86.  
  87.  return ( fehler );
  88. }                                                                /* main */
  89.  
  90.  
  91. /* -------------------------------------------------------------------- */
  92. /*        int rundschreiben_suchen ( MEMBLK *msginfopuffer,                */
  93. /*                                    RUNDINFO *rund, MSGINFO ** msg );    */
  94. /*                                                                        */
  95. /*        Sucht die Nummer des ersten Rundschreibens.                        */
  96. /*                                                                        */
  97. /*        ->    msginfopuffer    MSGINFO.DAT im Speicher.                    */
  98. /*            rund            Rundschreiben-Infos.                        */
  99. /*            msg                Eintrag in der MSGINFO.DAT.                    */
  100. /*                                                                        */
  101. /*        <-    fehler            Laufzeitfehler.                                */
  102. /* -------------------------------------------------------------------- */
  103.  
  104. int rundschreiben_suchen ( MEMBLK *msginfopuffer, RUNDINFO *rund, MSGINFO **msg )
  105. {
  106.  char        *ende, *pos, merk;
  107.  char        headerdatei[256];
  108.  int        fehler = 0;
  109.  MEMBLK        headerpuffer;
  110.  
  111.  rund->rund_nummer = 0;
  112.  ende = msginfopuffer->start + msginfopuffer->laenge;
  113.  *msg = (MSGINFO *)(msginfopuffer->start + 8);
  114.  do {
  115.     name_zusammensetzen( headerdatei, rund, (*msg)->nummer, ".HDR" );
  116.     fehler = datei_laden( headerdatei, &headerpuffer );
  117.     fehler_auswerten( headerdatei, fehler );
  118.     if ( fehler == 0 )
  119.         {
  120.         merk = *(headerpuffer.start + headerpuffer.laenge - 1);    /* Zeichen zwischenpuffern    */
  121.         *(headerpuffer.start + headerpuffer.laenge -1) = EOS;    /* um EOS setzen zu können.    */
  122.         pos = strstr( headerpuffer.start, rund->intro );        /* Nach dem Ende sollte man    */
  123.         *(headerpuffer.start + headerpuffer.laenge -1) = merk;    /* ja nicht schreiben.        */
  124.         if ( pos != NULL )
  125.             {
  126.             rund->rund_nummer = (*msg)->nummer;
  127.             memcpy( rund->rund_name, (char*)((size_t)(pos)+strlen(rund->intro)+1), 32 );
  128.             rund->rund_name[31] = EOS;
  129.             pos = memchr( rund->rund_name, 0x0D, 32 );
  130.             if ( pos != NULL )
  131.                 *pos = EOS;
  132.             strcpy( rund->rund_datei, rund->database );
  133.             strcat( rund->rund_datei, "\\" );
  134.             strcat( rund->rund_datei, rund->rund_name );
  135.             strcat( rund->rund_datei, ".INF" );
  136.             }
  137.         }
  138.     Mfree( headerpuffer.start );
  139.     (*msg)++;
  140.     } while ( ((char*)*msg < ende) && (fehler == 0) && (rund->rund_nummer == 0));
  141.  
  142.  (*msg)--;    /* wieder rücksetzen, um später darauf zugreifen zu können    */
  143.  
  144.  if ( (fehler == 0) && (rund->rund_nummer == 0) )
  145.     fehler = 1;
  146.  
  147.  return ( fehler );
  148. }                                                /* rundschreiben_suchen    */
  149.  
  150.  
  151. /* -------------------------------------------------------------------- */
  152. /*        int rundschreiben ( RUNDINFO *rund, MSGINFO *msg );                */
  153. /*                                                                        */
  154. /*        Das eigentliche Rundschreiben.                                    */
  155. /*                                                                        */
  156. /*        ->    rund            Infos aus CATRONDO.INF.                        */
  157. /*            msg                Teil aus MSGINFO.DAT im Speicher.            */
  158. /*                                                                        */
  159. /*        <-    fehler            Laufzeitfehler.                                */
  160. /* -------------------------------------------------------------------- */
  161.  
  162. int rundschreiben ( RUNDINFO *rund, MSGINFO *msg )
  163. {
  164.  int        fehler = 0;
  165.  MEMBLK        adresspuffer, headerpuffer, mailpuffer;
  166.  char        *naechste_adresse, adresse[256], headerdatei[256], maildatei[256];
  167.  
  168.  fehler = datei_laden( rund->rund_datei, &adresspuffer );
  169.  fehler_auswerten( rund->rund_datei, fehler );
  170.  if ( fehler == 0 )
  171.     {
  172.     fehler = plattenplatz_pruefen( &adresspuffer, rund );
  173.     if ( fehler == 0 )
  174.         {
  175.         name_zusammensetzen( headerdatei, rund, rund->rund_nummer, ".HDR" );
  176.         fehler = datei_laden( headerdatei, &headerpuffer );
  177.         fehler_auswerten( headerdatei, fehler );
  178.         if ( fehler == 0 )
  179.             {
  180.             naechste_adresse = adresse_holen( adresspuffer.start, adresse, adresspuffer.start+adresspuffer.laenge, rund );
  181.             fehler = neuen_header_schreiben( &headerpuffer, rund, rund->rund_nummer, adresse );
  182.             }
  183.         if ( fehler == 0 )
  184.             {
  185.             name_zusammensetzen( maildatei, rund, rund->rund_nummer, ".TXT" );
  186.             fehler = datei_laden( maildatei, &mailpuffer );
  187.             fehler_auswerten( maildatei, fehler );
  188.             if ( fehler == 0 )
  189.                 {
  190.                 verteiler_suchen( rund, &mailpuffer );
  191.                 if ( (*(rund->gruss) != EOS) || rund->verteiler )
  192.                     fehler = message_kopieren( &mailpuffer, rund, rund->rund_nummer, adresse, &adresspuffer );
  193.                 while ( (naechste_adresse != NULL) && (fehler == 0) )
  194.                     {
  195.                     naechste_adresse = adresse_holen( naechste_adresse, adresse, adresspuffer.start+adresspuffer.laenge, rund );
  196.                     (rund->hoechste_nummer)++;
  197.                     fehler = neuen_header_schreiben( &headerpuffer, rund, rund->hoechste_nummer, adresse );
  198.                     if ( fehler == 0 )
  199.                         {
  200.                         fehler = message_kopieren( &mailpuffer, rund, rund->hoechste_nummer, adresse, &adresspuffer );
  201.                         if ( fehler == 0 )
  202.                             fehler = msginfo_erweitern( rund, msg );
  203.                         }
  204.                     }
  205.                 }
  206.             Mfree( mailpuffer.start );
  207.             }
  208.         Mfree( headerpuffer.start );
  209.         }
  210.     Mfree( adresspuffer.start );
  211.     }
  212.  
  213.  return ( fehler );
  214. }                                                    /* rundschreiben    */
  215.  
  216.  
  217. /* -------------------------------------------------------------------- */
  218. /*        void verteiler_suchen ( RUNDINFO *rund, MEMBLK *mail )            */
  219. /*                                                                        */
  220. /*        Soll der Verteiler an die Message angehängt werden?                */
  221. /*                                                                        */
  222. /*        ->    mail            Hier steht die Ursprungsmail).                */
  223. /*                                                                        */
  224. /*        <-    rund->verteiler    Verteiler soll angehängt werden oder nicht.    */
  225. /* -------------------------------------------------------------------- */
  226.  
  227. void verteiler_suchen ( RUNDINFO *rund, MEMBLK *mail )
  228. {
  229.  char    *ende;
  230.  
  231.  rund->verteiler = FALSE;
  232.  
  233.  ende = mail->start + mail->laenge - 1;
  234.  while ( (*ende == '\n') || (*ende == '\r') )
  235.     ende--;
  236.  if ( strncmp( ende-9, "Verteiler:", 10 ) == 0 )
  237.     rund->verteiler = TRUE;
  238. }                                                    /* verteiler_suchen    */
  239.  
  240.  
  241. /* -------------------------------------------------------------------- */
  242. /*        char *adresse_holen ( char *start, char *adresse, char *ende,    */
  243. /*                                RUNDINFO *rund );                        */
  244. /*                                                                        */
  245. /*        Adresse aus der Liste holen.                                    */
  246. /*                                                                        */
  247. /*        ->    start            Ab hier suchen.                                */
  248. /*            ende            Bis hier suchen.                            */
  249. /*            rund            Infos...                                    */
  250. /*                                                                        */
  251. /*        <-    adresse            Adresse aus der Liste.                        */
  252. /*                            Nächster Anfang, NULL, wenn Ende.            */
  253. /* -------------------------------------------------------------------- */
  254.  
  255. char *adresse_holen ( char *start, char *adresse, char *ende, RUNDINFO *rund )
  256. {
  257.  char    *pos;
  258.  long    laenge;
  259.  char    selbstreferenz[100], rdatei[32];
  260.  
  261.  /* zunächst der Check, ob die Adresse auf die eigene Rundschreibenliste*/
  262.  /* zeigt, d.h. eine direkte Endlosschleife wird vermieden.                */
  263.  strcpy( selbstreferenz, rund->intro );    
  264.  strcat( selbstreferenz, " " );
  265.  d_get_dateiname( rund->rund_datei, rdatei );
  266.  pos = strchr( rdatei, '.' );
  267.  if ( pos != NULL )
  268.     *pos = EOS;
  269.  strcat( selbstreferenz, rdatei );
  270.  laenge = (long)(ende-start);
  271.  pos = memchr( start, 0x0d, laenge );
  272.  if ( pos != NULL )                        /* -> Zeilenende */
  273.     {
  274.     *pos = EOS;
  275.     strcpy( adresse, start );
  276.     pos += 2;
  277.     if ( ende-pos < 4 )        /* kurz vor Ende kann nichts    */
  278.         pos = NULL;            /* sinnvolles mehr da stehen.    */
  279.     }
  280.  else if ( ende-start > 3 )    /* es gibt kein Zeilenende, d.h.*/
  281.     {                        /* danach ist Schluß.            */
  282.     strncpy( adresse, start, laenge );
  283.     *(adresse+laenge) = EOS;
  284.     }
  285.  
  286.  /* Bei Selbstreferenz die nächste Adresse holen.            */
  287.  if ( (pos != NULL) && (strcmp( selbstreferenz, adresse )==0) )
  288.     pos = adresse_holen( pos, adresse, ende, rund );
  289.  
  290.  return ( pos );
  291. }                                                    /* adresse_holen    */
  292.  
  293.  
  294. /* -------------------------------------------------------------------- */
  295. /*        int neue_header_schreiben ( MEMBLK *puffer, int nummer,            */
  296. /*                    RUNDINFO *rund, char *adresse );                    */
  297. /*                                                                        */
  298. /*        Neue Headerdatei schreiben.                                        */
  299. /*                                                                        */
  300. /*        ->    puffer            Alter Header.                                */
  301. /*            rund            Infos...                                    */
  302. /*            nummer            neue Nummer.                                */
  303. /*            adresse            Neue Adresse.                                */
  304. /*                                                                        */
  305. /*        <-                    Laufzeitfehler.                                */
  306. /* -------------------------------------------------------------------- */
  307.  
  308. int neuen_header_schreiben ( MEMBLK *puffer, RUNDINFO *rund, int nummer, char *adresse )
  309. {
  310.  int    dhandle;
  311.  int    fehler = 0;
  312.  long    erg, len;
  313.  char    headerdatei[256], *pos;
  314.  
  315.  name_zusammensetzen( headerdatei, rund, nummer, ".HDR" );
  316.  dhandle = (int)Fcreate( headerdatei, 0 );
  317.  if ( dhandle <= 0 )
  318.     fehler = dhandle;
  319.  if ( fehler == 0 )
  320.     {
  321.     /* 1. Zeile separieren */
  322.     pos = memchr( puffer->start, 0x0d, puffer->laenge );
  323.     if ( pos!= NULL )
  324.         pos += 2;
  325.     else
  326.         fehler = 2;    /* Fehlerhafter Header */
  327.     /* 1. Zeile schreiben */
  328.     if ( fehler == 0 )
  329.         {
  330.         len = pos-puffer->start;
  331.         erg = Fwrite( dhandle, len, puffer->start );
  332.         if ( erg != len )
  333.             fehler = -10;
  334.         }
  335.     /* Adresse schreiben */
  336.     if ( fehler == 0 )
  337.         {
  338.         strcat( adresse, "\r\n" );
  339.         len = strlen(adresse);
  340.         erg = Fwrite( dhandle, len, adresse );
  341.         if ( erg != len )
  342.             fehler = -10;
  343.         }
  344.     /* 2. Zeile überlesen */
  345.     pos = memchr( pos, 0x0d, puffer->laenge-(long)pos+(long)puffer->start );
  346.     if ( pos!= NULL )
  347.         pos += 2;
  348.     else
  349.         fehler = 2;    /* Fehlerhafter Header */
  350.     /* Rest schreiben */
  351.     if ( fehler == 0 )
  352.         {
  353.         len = puffer->laenge-(long)pos+(long)puffer->start;
  354.         erg = Fwrite( dhandle, len, pos );
  355.         if ( erg != len )
  356.             fehler = -10;
  357.         }
  358.     Fclose( dhandle );
  359.     }
  360.  fehler_auswerten( headerdatei, fehler );
  361.  
  362.  return ( fehler );
  363. }                                            /* neuen_header_schreiben    */
  364.  
  365.  
  366. /* -------------------------------------------------------------------- */
  367. /*        int msginfo_erweitern ( MEMBLK *msginfopuffer, RUNDINFO *rund,    */
  368. /*                                MSGINFO *msg );                            */
  369. /*                                                                        */
  370. /*        MSGINFO.DAT erweitern.                                            */
  371. /*                                                                        */
  372. /*        ->    msginfopuffer    MSGINFO.DAT im Speicher.                    */
  373. /*            rund            Infos...                                    */
  374. /*            msg                Anzuhängendes Struct.                        */
  375. /*                                                                        */
  376. /*        <-                    Laufzeitfehler.                                */
  377. /* -------------------------------------------------------------------- */
  378.  
  379. int msginfo_erweitern ( RUNDINFO *rund, MSGINFO *msg )
  380. {
  381.  int    fehler = 0, dhandle;
  382.  long    erg, len;
  383.  char    tempdatei[256];
  384.  MEMBLK    msginfodat;
  385.  
  386.  fehler = datei_laden( rund->msginfodatei, &msginfodat );
  387.  fehler_auswerten( rund->msginfodatei, fehler );
  388.  if ( fehler == 0 )
  389.     {
  390.     strcpy( tempdatei, rund->msginfodatei );
  391.     d_set_extension( tempdatei, "$$$" );
  392.     dhandle = (int)Fcreate( tempdatei, 0 );
  393.     if ( dhandle <= 0 )
  394.         fehler = dhandle;
  395.     }
  396.  /* Anfang schreiben */
  397.  if ( fehler == 0 )
  398.     {
  399.     erg = Fwrite( dhandle, msginfodat.laenge, msginfodat.start );
  400.     if ( erg != msginfodat.laenge )
  401.         fehler = -10;
  402.     }
  403.  /* 1 Struct anhängen */
  404.  if ( fehler == 0 )
  405.     {
  406.     msg->nummer = rund->hoechste_nummer;
  407.     len = sizeof( *msg );
  408.     erg = Fwrite( dhandle, len, msg );
  409.     if ( erg != len )
  410.         fehler = -10;
  411.     }
  412.  Fclose( dhandle );
  413.  fehler_auswerten( tempdatei, fehler );
  414.  /* alte MSGINFO.DAT löschen und Temporärdatei Umbenennen    */
  415.  if ( fehler == 0 )
  416.     {
  417.     fehler = (int)Fdelete( rund->msginfodatei );
  418.     if ( fehler != 0 )
  419.         {
  420.         fehler = 3;
  421.         fehler_auswerten( rund->msginfodatei, fehler );
  422.         }
  423.     else
  424.         {
  425.         fehler = Frename( 0, tempdatei, rund->msginfodatei );
  426.         if ( fehler != 0 )
  427.             {
  428.             fehler = 4;
  429.             fehler_auswerten( tempdatei, fehler );
  430.             }
  431.         }
  432.     }
  433.  
  434.  return ( fehler );
  435. }                                                /* msginfo_erweitern    */
  436.  
  437.  
  438. /* -------------------------------------------------------------------- */
  439. /*        int message_kopieren ( MEMBLK *puffer, RUNDINFO *rund,            */
  440. /*                    int nummer, char *adresse, MEMBLK *adresspuffer );    */
  441. /*                                                                        */
  442. /*        Message kopieren (Text).                                        */
  443. /*                                                                        */
  444. /*        ->    puffer            Kopierpuffer (am Stück).                    */
  445. /*            rund            Infos...                                    */
  446. /*            nummer            neue Nummer.                                */
  447. /*            adresse            Zieladresse.                                */
  448. /*                                                                        */
  449. /*        <-                    Laufzeitfehler.                                */
  450. /* -------------------------------------------------------------------- */
  451.  
  452. int message_kopieren ( MEMBLK *puffer, RUNDINFO *rund, int nummer, char *adresse, MEMBLK *adresspuffer )
  453. {
  454.  int    dhandle;
  455.  int    fehler = 0;
  456.  long    erg, len;
  457.  char    maildatei[256], grusszeile[100], vorname[100], *pos;
  458.  
  459.  name_zusammensetzen( maildatei, rund, nummer, ".TXT" );
  460.  dhandle = (int)Fcreate( maildatei, 0 );
  461.  if ( dhandle <= 0 )
  462.     fehler = dhandle;
  463.  if ( fehler == 0 )
  464.     {
  465.     if ( *(rund->gruss) != EOS )    /* Gruß vorhanden    */
  466.         {
  467.         /* Vornamen ermitteln    */
  468.         strcpy( vorname, adresse );
  469.         pos = strpbrk( vorname, " _.@!%$&?=" );
  470.         if ( pos != NULL )
  471.             *pos = EOS;
  472.         /* Grußzeile aufbauen    */
  473.         strcpy( grusszeile, rund->gruss );
  474.         strcat( grusszeile, " " );
  475.         strcat( grusszeile, vorname );
  476.         strcat( grusszeile, "!\r\n\r\n" );
  477.         if ( strcmp( vorname, rund->intro ) != EOS )
  478.             {
  479.             len = strlen( grusszeile );
  480.             erg = Fwrite( dhandle, len, grusszeile );
  481.             if ( erg != len )
  482.                 fehler = -10;
  483.             }
  484.         }
  485.     if ( fehler == 0 )
  486.         {
  487.         erg = Fwrite( dhandle, puffer->laenge, puffer->start );
  488.         if ( erg != puffer->laenge )
  489.             fehler = -10;
  490.         }
  491.     if ( (fehler == 0) && (rund->verteiler) )
  492.         {
  493.         erg = Fwrite( dhandle, adresspuffer->laenge, adresspuffer->start );
  494.         if ( erg != adresspuffer->laenge )
  495.             fehler = -10;
  496.         }
  497.  
  498.     Fclose( dhandle );
  499.     }
  500.  fehler_auswerten( maildatei, fehler );
  501.  
  502.  return ( fehler );
  503. }                                                    /* message_kopieren    */
  504.  
  505.  
  506. /* -------------------------------------------------------------------- */
  507. /*        int hoechste_nummer ( MEMBLK *msginfopuffer );                    */
  508. /*                                                                        */
  509. /*        Liefert die größte verwendete Messagenummer.                    */
  510. /*                                                                        */
  511. /*        ->    msginfopuffer    MSGINFO.DAT im Speicher.                    */
  512. /*                                                                        */
  513. /*        <-    nummer            Nummer der Message.                            */
  514. /* -------------------------------------------------------------------- */
  515.  
  516. int hoechste_nummer ( MEMBLK *msginfopuffer )
  517. {
  518.  char        *ende;
  519.  MSGINFO    *msg;
  520.  int        nummer = 0;
  521.  
  522.  ende = msginfopuffer->start + msginfopuffer->laenge;
  523.  msg = (MSGINFO *)(msginfopuffer->start + 8);
  524.  do {
  525.     if ( msg->nummer > nummer )
  526.         nummer = msg->nummer;
  527.     msg++;
  528.     } while ( (char*)msg < ende );
  529.  
  530.  return ( nummer );
  531. }                                                    /* hoechste_nummer    */
  532.  
  533.  
  534. /* -------------------------------------------------------------------- */
  535. /*        void name_zusammensetzen ( char *headerdatei, RUNDINFO *rund,    */
  536. /*                                int nummer, const char *extension );    */
  537. /*                                                                        */
  538. /*        Name der Messagedatei zusammensetzen.                            */
  539. /*                                                                        */
  540. /*        ->    rund            Infos: Pfad, etc.                            */
  541. /*            nummer            Nummer der Message.                            */
  542. /*            extension        Header oder Text.                            */
  543. /*                                                                        */
  544. /*        <-    headerdatei        Name der Headerdatei.                        */
  545. /* -------------------------------------------------------------------- */
  546.  
  547. void name_zusammensetzen ( char *headerdatei, RUNDINFO *rund, int nummer, const char *extension )
  548. {
  549.  char    num[8] = "0000";
  550.  
  551.  strcpy( headerdatei, rund->messages );
  552.  strcat( headerdatei, "\\MSG" );
  553.  
  554.  if ( nummer > 99 )
  555.     itoa( nummer, num, 10 );
  556.  else if ( nummer > 9 )
  557.     itoa( nummer, num+1, 10 );
  558.  else
  559.     itoa( nummer, num+2, 10 );
  560.  
  561.  strcat( headerdatei, num );
  562.  strcat( headerdatei, extension );
  563. }                                            /* header_zusammensetzen    */
  564.  
  565.  
  566. /* -------------------------------------------------------------------- */
  567. /*        int plattenplatz_pruefen ( MEMBLK *adresspuffer,                */
  568. /*                                    RUNDINFO *rund );                    */
  569. /*                                                                        */
  570. /*        Prüft, ob genügend Platz auf der Platte ist.                    */
  571. /*                                                                        */
  572. /*        ->    adresspuffer    RUND.INF im Speicher.                        */
  573. /*            rund            Rundschreiben-Infos.                        */
  574. /*                                                                        */
  575. /*        <-    fehler            Laufzeitfehler.    (2: Plattenplatz)            */
  576. /* -------------------------------------------------------------------- */
  577.  
  578. int plattenplatz_pruefen ( MEMBLK *adresspuffer, RUNDINFO *rund )
  579. {
  580.  char            *pos, *ende, *cr;
  581.  int            anzahl = 0, lw, fehler = 0;
  582.  unsigned long    platzbedarf, frei;
  583.  DISKINFO        di;
  584.  
  585.  pos = adresspuffer->start;
  586.  ende = adresspuffer->start + adresspuffer->laenge;
  587.  do {
  588.     anzahl++;
  589.     cr = memchr( pos, 0x0D, ende-pos );
  590.     if ( cr != NULL )
  591.         pos = cr+1;
  592.     } while ( cr != NULL );
  593.  platzbedarf = (long)anzahl << 14; /* 16kB pro Message */
  594.  d_get_laufwerk( rund->database, &lw );
  595.  Dfree( &di, lw );
  596.  frei = di.b_free * di.b_secsiz * di.b_clsiz;
  597.  if ( frei < platzbedarf )
  598.     fehler = 5;
  599.  fehler_auswerten( rund->rund_datei, fehler );
  600.  
  601.  return ( fehler );
  602. }                                                /* plattenplatz_pruefen    */
  603.  
  604.  
  605. /* -------------------------------------------------------------------- */
  606. /*        int rundinfo_auswerten ( MEMBLK *puffer, RUNDINFO *rund );        */
  607. /*                                                                        */
  608. /*        Infodatei von CATRONDO auswerten.                                */
  609. /*                                                                        */
  610. /*        ->    puffer            In diesem Puffer steht CATRONDO.INF.        */
  611. /*                                                                        */
  612. /*        <-    rund            In dieses Struct sollen die Daten.            */
  613. /* -------------------------------------------------------------------- */
  614.  
  615. int rundinfo_auswerten ( MEMBLK *puffer, RUNDINFO *rund )
  616. {
  617.  BOOLEAN    ok = TRUE;
  618.  char        *pos, *ende;
  619.  char        testdat[256];
  620.  int        fehler = 0;
  621.  
  622.  pos = puffer->start;
  623.  ende = puffer->start + puffer->laenge;
  624.  
  625.  ok = zeile_lesen( &pos, ende, rund->database );
  626.  if ( ok )
  627.     ok = zeile_lesen( &pos, ende, rund->messages );
  628.  if ( ok )
  629.     ok = zeile_lesen( &pos, ende, rund->intro );
  630.  if ( ok )
  631.     ok = zeile_lesen( &pos, ende, rund->gruss );
  632.  if ( ok )
  633.     {
  634.     strcpy( rund->msginfodatei, rund->messages );
  635.     strcat( rund->msginfodatei, "\\MSGINFO.DAT" );
  636.     strcpy( testdat, rund->database );
  637.     strcat( testdat, "\\PRIVATE.DAT" );
  638.     if ( ( Fsfirst( rund->msginfodatei, 0 ) != 0 ) ||
  639.          ( Fsfirst( testdat, 0 ) != 0 ) )
  640.         ok = FALSE;
  641.     }
  642.  if ( !ok )
  643.     fehler = 6;
  644.  
  645.  return ( fehler );
  646. }                                                /* rundinfo_auswerten    */
  647.  
  648.  
  649. /* -------------------------------------------------------------------- */
  650. /*        BOOLEAN zeile_lesen ( char **pos, char *ende, char *var );        */
  651. /*                                                                        */
  652. /*        Zeile aus CATRONDO.INF auslesen.                                */
  653. /*                                                                        */
  654. /*        ->    ende            Endmarker von CATRONDO.INF.                    */
  655. /*                                                                        */
  656. /*        <>    pos                Leseposition innerhalb von CATRONDO.INF.    */
  657. /*                                                                        */
  658. /*        <-    var                Stringvariable.                                */
  659. /*                            Erfolgreiches Auslesen oder nicht.            */
  660. /* -------------------------------------------------------------------- */
  661.  
  662. BOOLEAN zeile_lesen ( char **pos, char *ende, char *var )
  663. {
  664.  char        *cr;
  665.  BOOLEAN    ok = TRUE;
  666.  
  667.  *var = EOS;
  668.  if ( *pos >= ende )
  669.     ok = FALSE;
  670.  else
  671.     {
  672.     cr = memchr( *pos, 0x0D, ende-(*pos) );
  673.     if ( cr == NULL )
  674.         {
  675.         strncpy( var, *pos, ende-(*pos) );
  676.         *(ende - (*pos) + var) = EOS;
  677.         }
  678.     else
  679.         {
  680.         *cr = EOS;
  681.         strcpy( var, *pos );
  682.         (*pos) = cr+2;
  683.         if ( (*pos) >= ende )
  684.             *pos = ende;
  685.         }
  686.     }
  687.  
  688.  return ( ok );
  689. }                                                        /* zeile_lesen    */
  690.  
  691.  
  692. /* -------------------------------------------------------------------- */
  693. /*        void fehler_auswerten ( char *dateiname, int fehler );            */
  694. /*                                                                        */
  695. /*        Fehlerausgabe.                                                    */
  696. /*                                                                        */
  697. /*        ->    dateiname        Name der Datei.                                */
  698. /*            fehler            GEMDOS-Fehlernummer.                        */
  699. /*                                                                        */
  700. /*        <-                    Nichts.                                        */
  701. /* -------------------------------------------------------------------- */
  702.  
  703. void fehler_auswerten ( char *dateiname, int fehler )
  704. {
  705.  char fehlertext[200], fehlernr[10], fdatei[64];
  706.  
  707.  if ( fehler != 0 )
  708.     {
  709.     strcpy( fehlertext, "[1][ CATRONDO:| " );
  710.     switch ( fehler )
  711.         {
  712.         case 1:
  713.             strcat( fehlertext, "Nichts zu tun!" ); break;
  714.         case 5:
  715.             strcat( fehlertext, "Zu wenig Platz auf dem| Speichermedium!" ); break;
  716.         default:
  717.             d_get_dateiname( dateiname, fdatei );
  718.             fdatei[30] = EOS; /* Um der Alertbox keine Schwierigkeiten zu machen...*/
  719.             strcat( fehlertext, "Fehler in Datei| " );
  720.             strcat( fehlertext, fdatei );
  721.             strcat( fehlertext, "| " );
  722.             switch ( fehler )
  723.                 {
  724.                 case 2:
  725.                     strcat( fehlertext, "Fehlerhafte Headerdatei!" ); break;
  726.                 case 3:
  727.                     strcat( fehlertext, "Fehler beim Löschen!" ); break;
  728.                 case 4:
  729.                     strcat( fehlertext, "Fehler beim Umbenennen!" ); break;
  730.                 case 6:
  731.                     strcat( fehlertext, "Fehlerhafte Eintragungen!" ); break;
  732.                 case -10:
  733.                     strcat( fehlertext, "Schreibfehler!" ); break;
  734.                 case -11:
  735.                     strcat( fehlertext, "Lesefehler!" ); break;
  736.                 case -13:
  737.                     strcat( fehlertext, "Das Speichermedium ist| schreibgeschützt!" ); break;
  738.                 case -33:
  739.                     strcat( fehlertext, "Datei nicht gefunden!" ); break;
  740.                 case -34:
  741.                     strcat( fehlertext, "Ordner nicht gefunden!" ); break;
  742.                 case -35:
  743.                     strcat( fehlertext, "Zu viele Dateien geöffnet!" ); break;
  744.                 case -36:
  745.                     strcat( fehlertext, "Zugriff nicht erlaubt!" ); break;
  746.                 case -39:
  747.                     strcat( fehlertext, "Nicht genügend Speicher| vorhanden !" ); break;
  748.                 case -49:
  749.                     strcat( fehlertext, "Es können keine Dateien| mehr geöffnet werden!" ); break;
  750.                 default:
  751.                     itoa( fehler, fehlernr, 10 );
  752.                     strcat( fehlertext, "GEMDOS-Fehler Nr. " );
  753.                     strcat( fehlertext, fehlernr );
  754.                     break;
  755.                 }
  756.         }
  757.     strcat( fehlertext, "][  . . .  ]" );
  758.     form_alert( 1, fehlertext );
  759.     }
  760. }                                                    /* fehler_auswerten    */
  761.  
  762.  
  763. /* -------------------------------------------------------------------- */
  764. /*        int datei_laden ( const char *dateiname, MEMBLK *dateipuffer );    */
  765. /*                                                                        */
  766. /*        Datei in einen eigenen Puffer laden.                            */
  767. /*                                                                        */
  768. /*        ->    dateiname        Name der Datei.                                */
  769. /*                                                                        */
  770. /*        <-    dateipuffer        Puffer der Datei.                            */
  771. /*                            Aufgetretener Fehler = GEMDOS-Fehlernummer.    */
  772. /* -------------------------------------------------------------------- */
  773.  
  774. int datei_laden ( const char *dateiname, MEMBLK *dateipuffer )
  775. {
  776.  unsigned long    erg;
  777.  long            mem_frei;
  778.  int            dhandle;
  779.  int            fehler = 0;
  780.  
  781.  dateipuffer->start = NULL;
  782.  dateipuffer->laenge = 0;
  783.  
  784.  fehler = Fsfirst( dateiname, 0 );
  785.  if ( fehler == 0 )
  786.     {
  787.     dateipuffer->laenge = Fgetdta()->d_length;
  788.     mem_frei = (long)Malloc( -1 );
  789.     if ( mem_frei < dateipuffer->laenge )
  790.         fehler = -39;
  791.     else
  792.         {
  793.         dateipuffer->start = Malloc( dateipuffer->laenge );
  794.         if ( dateipuffer->start == 0 )
  795.             fehler = -39;
  796.         else
  797.             {
  798.             dhandle = (int)Fopen( dateiname, FO_READ );
  799.             if ( dhandle <= 0 )
  800.                 fehler = dhandle;
  801.             else
  802.                 {
  803.                 erg = Fread( dhandle, dateipuffer->laenge, dateipuffer->start );
  804.                 Fclose( dhandle);
  805.                 if ( erg != dateipuffer->laenge )
  806.                     fehler = -11;
  807.                 }
  808.             if ( fehler != 0 )
  809.                 {
  810.                 Mfree( dateipuffer->start );
  811.                 dateipuffer->start = NULL;
  812.                 dateipuffer->laenge = 0;
  813.                 }
  814.             }
  815.         }
  816.     }
  817.  
  818.  return ( fehler );
  819. }                                                        /* datei_laden    */
  820.  
  821.  
  822. /* -------------------------------------------------------------------- */
  823. /*        int d_get_laufwerk ( const char *pfad, int *drv );                */
  824. /*                                                                        */
  825. /*        Ermittelt Laufwerk; wenn in der Pfadangabe keine                */
  826. /*        Laufwerksangabe ist, wird das aktuelle Laufwerk zurückgegeben.    */
  827. /*                                                                        */
  828. /*        ->    pfad                 Vollständiger Pfadname.                 */
  829. /*                                                                        */
  830. /*        <-    drv                    Laufwerk (1:A, 2:B, ...).                 */
  831. /*                                Wenn aktuelles Laufwerk, dann ist der    */
  832. /*                                Rückgabewert 1, sonst 0.                */
  833. /* -------------------------------------------------------------------- */
  834.  
  835. int d_get_laufwerk ( const char *pfad, int *drv )
  836. {
  837.  int    ret = 0;
  838.  
  839.  if ( (pfad[0]>='A') && (pfad[0]<='Z') && (pfad[1]==':') )
  840.     *drv = pfad[0] - 'A' + 1;
  841.   else
  842.    {
  843.     *drv = Dgetdrv() + 1;
  844.     ret = 1;
  845.    }
  846.  
  847.  return ( ret );
  848. }                                                    /* d_get_laufwerk() */
  849.  
  850.  
  851. /* -------------------------------------------------------------------- */
  852. /*        int d_get_pfadname ( const char *vollstaendiger_pfad,            */
  853. /*                             char *pfad, BOOLEAN lw );                    */
  854. /*                                                                        */
  855. /*        Ermittelt Pfad aus der Angabe eines vollständigen Pfades;        */
  856. /*        Wenn der vollständige Pfad leer ist, wird der aktuelle Pfad        */
  857. /*        des aktuellen Laufwerks zurückgegeben.                            */
  858. /*                                                                        */
  859. /*        ->    vollstaendiger_pfad    Vollständiger Pfadname.                 */
  860. /*            lw                    Pfadname soll Laufwerk enthalten,        */
  861. /*                                falls vorhanden.                        */
  862. /*                                                                        */
  863. /*        <-    pfad                 Pfadname.                                 */
  864. /*                                Wenn aktueller Pfad, dann ist der        */
  865. /*                                Rückgabewert 1, sonst 0, im Fehlerfall    */
  866. /*                                beim akt. Pfad die Fehlernummer.        */
  867. /* -------------------------------------------------------------------- */
  868.  
  869. int d_get_pfadname ( const char *vollstaendiger_pfad, char *pfad, BOOLEAN lw )
  870. {
  871.  int        ret = 0;
  872.  char        *pfadanfang, *pfadende, v_pfad[STPATHLEN+1];
  873.  
  874.  strcpy( v_pfad, vollstaendiger_pfad );
  875.  if ( v_pfad[0] == EOS )
  876.    {
  877.     ret = Dgetdrv();
  878.     if ( ret >= 0 )
  879.        {
  880.         if ( lw )
  881.            {
  882.             v_pfad[0] = ret+65;
  883.             v_pfad[1] = ':';
  884.             v_pfad[2] = EOS;
  885.             ret = Dgetpath( v_pfad+2, ret+1 );
  886.            }
  887.          else
  888.             ret = Dgetpath( pfad, ret+1 );
  889.         if ( ret == 0 )
  890.            {
  891.             ret = 1;
  892.             if ( lw )
  893.                 strcpy( pfad, v_pfad );
  894.            }
  895.        }
  896.    }
  897.   else        /* v_pfad nicht leer */
  898.    {
  899.     if ( ( v_pfad[0] >= 'A' ) &&            /* am Anfang steht    */
  900.          ( v_pfad[0] <= 'Z' ) &&            /* das Laufwerk        */
  901.          ( v_pfad[1] == ':' ) )
  902.        {
  903.         if ( v_pfad[2] != '\\' )            /* falls kein \        */
  904.            {                                /* Fehler            */
  905.             pfad[0] = ':';                    /* korrigieren        */
  906.             pfad[1] = EOS;
  907.             strcpy( pfad+2, v_pfad+2 );
  908.             strcpy( v_pfad+2, pfad );
  909.            }
  910.         if ( lw )
  911.             pfadanfang = v_pfad;
  912.          else
  913.             pfadanfang = &v_pfad[2];
  914.        }
  915.      else                    /* Laufwerk stand nicht am Anfang    */
  916.        {
  917.         pfadanfang = v_pfad;
  918.         if ( lw )            /* soll aber da sein    */
  919.            {
  920.             ret = Dgetdrv();
  921.             if ( ret >= 0 )
  922.                {
  923.                 pfad[0] = ret+65;
  924.                 pfad[1] = ':';
  925.                 if ( v_pfad[0] == '\\' )
  926.                    {
  927.                     pfad[2] = EOS;
  928.                     strcpy( pfad+2, v_pfad );
  929.                    }
  930.                  else
  931.                    {
  932.                     pfad[2] = '\\';
  933.                     pfad[3] = EOS;
  934.                     strcpy( pfad+3, v_pfad );
  935.                    }
  936.                 strcpy( v_pfad, pfad );
  937.                 pfadanfang = v_pfad;
  938.                }            /* ret <0    */
  939.            }                /* not lw    */
  940.        }
  941.  
  942.     if ( ret >= 0 )
  943.        {
  944.         pfadende = strrchr( pfadanfang, '\\' );
  945.         if ( pfadende == 0 )
  946.             pfad[0] = EOS;
  947.          else
  948.            {
  949.             strncpy( pfad, pfadanfang, pfadende - pfadanfang + 1);
  950.             pfad[pfadende-pfadanfang+1] = EOS;
  951.            }
  952.        }
  953.      else
  954.         pfad[0] = EOS;
  955.    }
  956.  
  957.  if ( ret < 0 )
  958.    {
  959.     pfad[0] = EOS;
  960.    }
  961.  
  962.  return ( ret );
  963. }                                                    /* d_get_pfadname() */
  964.  
  965.  
  966. /* -------------------------------------------------------------------- */
  967. /*        void d_get_dateiname ( const char *pfad, char *datei );            */
  968. /*                                                                        */
  969. /*        Extrahiert den Dateinamen aus einem Pfad.                        */
  970. /*                                                                        */
  971. /*        ->    pfad                 Vollständiger Pfadname.                 */
  972. /*                                                                        */
  973. /*        <>    datei                Dateiname.                                 */
  974. /* -------------------------------------------------------------------- */
  975.  
  976. void d_get_dateiname ( const char *pfad, char *datei )
  977. {
  978.  char     *pos, *dateianfang, temp[STPATHLEN+1];
  979.  
  980.  strcpy( temp, pfad );
  981.  pos = strrchr( temp, '\\' );
  982.  if ( pos == NULL )
  983.     dateianfang = temp;
  984.   else
  985.     dateianfang = pos + 1;
  986.  strcpy( datei, dateianfang );
  987. }                                                   /* d_get_dateiname() */
  988.  
  989.  
  990. /* -------------------------------------------------------------------- */
  991. /*        void d_get_extension ( const char *datei, char *ext );            */
  992. /*                                                                        */
  993. /*        Extrahiert die Extension aus einem Pfad.                        */
  994. /*                                                                        */
  995. /*        ->    datei                Datei- oder Pfadname.                     */
  996. /*                                                                        */
  997. /*        <-    ext                    Extension.                                */
  998. /* -------------------------------------------------------------------- */
  999.  
  1000. void d_get_extension ( const char *datei, char *ext )
  1001. {
  1002.  char    *pos_punkt, *pos_slash;
  1003.  
  1004.  pos_punkt = strrchr( datei, '.' );
  1005.  pos_slash = strrchr( datei, '\\' );
  1006.  if ( (pos_punkt != NULL) && (pos_slash != NULL) )
  1007.    {
  1008.     if ( pos_punkt < pos_slash )
  1009.         ext[0] = EOS;
  1010.      else
  1011.         strcpy( ext, pos_punkt + 1 );
  1012.    }
  1013.  else if ( pos_punkt == NULL )
  1014.     ext[0] = EOS;
  1015.   else
  1016.     strcpy( ext, pos_punkt + 1 );
  1017. }                                                   /* d_get_extension() */
  1018.  
  1019.  
  1020. /* -------------------------------------------------------------------- */
  1021. /*        void d_set_extension ( char *datei, const char *ext );            */
  1022. /*                                                                        */
  1023. /*        Extension einer Datei setzen.                                    */
  1024. /*                                                                        */
  1025. /*        ->    ext                 zu setzende Extension.                     */
  1026. /*                                                                        */
  1027. /*        <>    datei                Dateiname.                                 */
  1028. /* -------------------------------------------------------------------- */
  1029.  
  1030. void d_set_extension ( char *datei, const char *ext )
  1031. {
  1032.  char    *pos,         /* absolute Position eines Zeichens in einem String */
  1033.         punkt[2];     /* "."                                                */
  1034.  
  1035.  pos = strrchr( datei, '.' );
  1036.  if ( pos != NULL )
  1037.    {
  1038.     pos += 1;
  1039.     strcpy( pos, ext );
  1040.    }
  1041.   else
  1042.    {
  1043.     strcpy( punkt, "." );
  1044.     strcat( datei, punkt );
  1045.     strcat( datei, ext );
  1046.    }
  1047. }                                                   /* d_set_extension() */
  1048.  
  1049.  
  1050. /* -------------------------------------------------------------------- */
  1051. /*        void dateiname ( char *dest, int drv,    const char *s1,            */
  1052. /*                                                const char *s2 );        */
  1053. /*                                                                        */
  1054. /*        Konkatoniere Pfadnamen und Dateinamen.                             */
  1055. /*                                                                        */
  1056. /*        ->    drv                 Laufwerk.                                */
  1057. /*            s1                    Pfadname.                                */
  1058. /*            s2                    Dateiname.                                 */
  1059. /*                                                                        */
  1060. /*        <>    dest                Zielstring.                                */
  1061. /* -------------------------------------------------------------------- */
  1062.  
  1063. void dateiname ( char *dest, int drv, const char *s1, const char *s2 )
  1064. {
  1065.  char    bs[2] = "\\",                        /* BACKSPACE                */
  1066.         temp[STPATHLEN+1];                    /* Zwischenspeicher         */
  1067.  
  1068.  strcpy( temp, dest );
  1069.  
  1070.  if ( drv > 0 )                             /* drv = 1 -> Laufwerk A    */
  1071.    {
  1072.     temp[0] = drv + 'A' - 1;                /* Laufwerk 1 -> A            */
  1073.     temp[1] = ':';                            /*                 :            */
  1074.     temp[2] = EOS;
  1075.    }
  1076.   else                                        /* drv = 0 -> kein Laufwerk */
  1077.     temp[0] = EOS;
  1078.  
  1079.  if ( s1[0] == EOS)
  1080.    {
  1081.     if ( drv > 0 )
  1082.         strcat( temp, bs );
  1083.    }
  1084.   else                                        /* Pfad != ""                */
  1085.    {
  1086.     if ( ( drv > 0 ) && ( s1[0] != '\\' ) )
  1087.         strcat( temp, bs );
  1088.     strcat( temp, s1 );
  1089.     if ( temp[strlen( temp)-1] != '\\' )    /* falls Pfad nicht mit \     */
  1090.         strcat( temp, bs );                    /* endet, \ anhängen        */
  1091.    }
  1092.  
  1093.  if ( s2[0] != EOS )                        /* Datei != ""                */
  1094.     strcat( temp, s2 );
  1095.  
  1096.  strcpy( dest, temp );
  1097. }                                                         /* dateiname() */
  1098.  
  1099. /************************************************************************/
  1100. /*        E n d e        CATRONDO.C                                            */
  1101. /************************************************************************/
  1102.